import _ from 'lodash'
//import qipan from 'qipan'
function format() {
    ///	<summary>
    ///	字符串格式化。第一个参数是格式，第二个参数是格式化的第一个参数，第三个参数是格式化的第二个参数...
    /// var fmt = "Hello {0}!";Swao.utils.String.format(fmt, "Andrew");
    ///	</summary>
    ///	<param name="str" type="String">输入字符串</param>
    ///	<returns type="int">字符串长度(中文2个字符)</returns>

    if (arguments.length == 0)
        return null;
    var str = arguments[0];
    var re = '', i = 0;
    // 如果第二个参数是数组
    if (_.isArray(arguments[1])) {
        var array = arguments[1];
        for (; i < array.length; i++) {
            re = new RegExp('\\{' + i + '\\}', 'gm');
            str = str.replace(re, array[i]);
        }
    } else {
        for (i = 1; i < arguments.length; i++) {
            re = new RegExp('\\{' + (i - 1) + '\\}', 'gm');
            str = str.replace(re, arguments[i]);
        }
    }
    return str;
}

function isObjectAttribute(obj,attributes){ // 是否是对象的属性 is object attribute
    if(_.isObject(obj)){ // 只有对象成立
        if(_.isArray(obj)){ // 数组返回false
            return false;
        }else{
            if(_.isArray(attributes)){
                let len = attributes.length - 1;
                attributes.forEach(function(attr,i){
                    if(_.isObject(obj)){
                        obj = obj[attr];
                    }else{
                        if(i < len){
                            return false;
                        }
                    }
                });
                return obj;
            }else{
                if(_.isString(attributes)){
                    return obj[attributes];
                }
            }
        }
    }
    return false;
}


// 本地存储- 存储  并设置过期分钟
// 目前存储做全覆盖存储
function setCookie(cookieName, data, minutes) {

    var cookieData = {
        data:data
    };
    removeCookie(cookieName);
    if (!!minutes) {
        cookieData.beginTime = (new Date()).getTime();
        cookieData.effectiveMin = minutes;
    }
    //console.log('setCookie',cookieName,cookieData,JSON.stringify(cookieData));
    window.localStorage.setItem(cookieName, JSON.stringify(cookieData));
}

// 本地存储- 获取
function getCookie(cookieName) {
    // 传入的cookieName必须存在
    //console.log('in getCookie',cookieName)
    if(!(typeof cookieName == 'string' || typeof cookieName == 'number')) return null;
    var _ls = window.localStorage.getItem(cookieName);
    //console.log('getCookie',cookieName,_ls)
    if(_ls != null){ // 存在指定的本地存储
        var _ls_data = JSON.parse(_ls).data; //  存储的实际内容
        var endTime = (new Date()).getTime();
        if (!!_ls.beginTime && !!_ls.effectiveMin) {  // 存储内容存在开始时间和有效时长
            if (getDateInterval(_ls.beginTime, endTime, 'minutes') > parseInt(_ls.effectiveMin)) {
                removeCookie(cookieName); // 存储超期，直接删除
                return null;
            } else {
               return _ls_data;
            }
        } else {
            return _ls_data;
        }
    }
    return null;
}

// 本地存储- 获取
function removeCookie(cookieName) {
    window.localStorage.removeItem(cookieName);
}

// 根据类型获取日期间隔
// beginTime 起始时间  endTime 结束时间
// type  日  时 分 秒 类型
function getDateInterval(beginTime, endTime, type) {
    if (typeof type == 'undefined') {
        return;
    }
    beginTime = parseInt(beginTime);
    endTime = parseInt(endTime);
    switch (type) {
        case 'day':
            return Math.abs(endTime - beginTime) / 1000 / 60 / 60 / 24;
        case 'hour':
            return Math.abs(endTime - beginTime) / 1000 / 60 / 60;
        case 'minutes':
            return Math.abs(endTime - beginTime) / 1000 / 60;
        case 'seconds':
            return Math.abs(endTime - beginTime) / 1000;
        default:
            break;
    }

}


// 浮点数加法 a + b
function accAdd(a, b) {
    var c, d, e;
    try {
        c = a.toString().split(".")[1].length;
    } catch (f) {
        c = 0;
    }
    try {
        d = b.toString().split(".")[1].length;
    } catch (f) {
        d = 0;
    }
    return e = Math.pow(10, Math.max(c, d)), (accMul(a, e) + accMul(b, e)) / e;
}

// 浮点数减法 a - b
function accSub(a, b) {
    var c, d, e;
    try {
        c = a.toString().split(".")[1].length;
    } catch (f) {
        c = 0;
    }
    try {
        d = b.toString().split(".")[1].length;
    } catch (f) {
        d = 0;
    }
    return e = Math.pow(10, Math.max(c, d)), (accMul(a, e) - accMul(b, e)) / e;
}

// 浮点数乘法 a * b
function accMul(a, b) {
    var c = 0,
        d = a.toString(),
        e = b.toString();
    try {
        c += d.split(".")[1].length;
    } catch (f) {
    }
    try {
        c += e.split(".")[1].length;
    } catch (f) {
    }
    return Number(d.replace(".", "")) * Number(e.replace(".", "")) / Math.pow(10, c);
}

// 浮点数除法 a / b
function accDiv(a, b) {
    var c, d, e = 0,
        f = 0;
    try {
        e = a.toString().split(".")[1].length;
    } catch (g) {
    }
    try {
        f = b.toString().split(".")[1].length;
    } catch (g) {
    }
    return c = Number(a.toString().replace(".", "")), d = Number(b.toString().replace(".", "")), accMul(c / d, Math.pow(10, f - e));
}

/* 功能：生成一个GUID码，其中GUID以14个以下的日期时间及18个以上的16进制随机数组成，
 * GUID存在一定的重复概率，但重复概率极低，
 * 理论上重复概率为每10ms有1/(16^18)，即16的18次方分之1，
 * 重复概率低至可忽略不计
 */
function GUID() {
    this.date = new Date();
    /* 判断是否初始化过，如果初始化过以下代码，则以下代码将不再执行，实际中只执行一次 */
    if (typeof this.newGUID != 'function') {

        /* 生成GUID码 */
        GUID.prototype.newGUID = function() {
            this.date = new Date();
            var guidStr = '';
            var sexadecimalDate = this.hexadecimal(this.getGUIDDate(), 16);
            var sexadecimalTime = this.hexadecimal(this.getGUIDTime(), 16);
            for (var i = 0; i < 9; i++) {
                guidStr += Math.floor(Math.random()*16).toString(16);
            }
            guidStr += sexadecimalDate;
            guidStr += sexadecimalTime;
            while(guidStr.length < 32) {
                guidStr += Math.floor(Math.random()*16).toString(16);
            }
            return this.formatGUID(guidStr);
        };

        /*
         * 功能：获取当前日期的GUID格式，即8位数的日期：19700101
         * 返回值：返回GUID日期格式的字条串
         */
        GUID.prototype.getGUIDDate = function() {
            return this.date.getFullYear() + this.addZero(this.date.getMonth() + 1) + this.addZero(this.date.getDay());
        };

        /*
         * 功能：获取当前时间的GUID格式，即8位数的时间，包括毫秒，毫秒为2位数：12300933
         * 返回值：返回GUID日期格式的字条串
         */
        GUID.prototype.getGUIDTime = function() {
            return this.addZero(this.date.getHours()) + this.addZero(this.date.getMinutes()) + this.addZero(this.date.getSeconds()) + this.addZero( parseInt(this.date.getMilliseconds() / 10 ));
        };

        /*
         * 功能: 为一位数的正整数前面添加0，如果是可以转成非NaN数字的字符串也可以实现
         * 参数: 参数表示准备再前面添加0的数字或可以转换成数字的字符串
         * 返回值: 如果符合条件，返回添加0后的字条串类型，否则返回自身的字符串
         */
        GUID.prototype.addZero = function(num) {
            if (Number(num).toString() != 'NaN' && num >= 0 && num < 10) {
                return '0' + Math.floor(num);
            } else {
                return num.toString();
            }
        };

        /*
         * 功能：将y进制的数值，转换为x进制的数值
         * 参数：第1个参数表示欲转换的数值；第2个参数表示欲转换的进制；第3个参数可选，表示当前的进制数，如不写则为10
         * 返回值：返回转换后的字符串
         */
        GUID.prototype.hexadecimal = function(num, x, y) {
            if (y != undefined) {
                return parseInt(num.toString(), y).toString(x);
            } else {
                return parseInt(num.toString()).toString(x);
            }
        };

        /*
         * 功能：格式化32位的字符串为GUID模式的字符串
         * 参数：第1个参数表示32位的字符串
         * 返回值：标准GUID格式的字符串
         */
        GUID.prototype.formatGUID = function(guidStr) {
            var str1 = guidStr.slice(0, 8) + '-',
                str2 = guidStr.slice(8, 12) + '-',
                str3 = guidStr.slice(12, 16) + '-',
                str4 = guidStr.slice(16, 20) + '-',
                str5 = guidStr.slice(20);
            return str1 + str2 + str3 + str4 + str5;
        };
    }
}

function toPercent(num,len){
    return (Math.round(num * 10000) / 100).toFixed(len||5) + '%';
}

function swap(array,first,second){
    var tmp = array[second];
    array[second] = array[first];
    array[first] = tmp;
    return array;
}

export default{
    accAdd: accAdd, // 浮点数加法
    accSub: accSub, // 浮点数减法
    accMul: accMul, // 浮点数乘法
    accDiv: accDiv, // 浮点数除法
    isObjectAttribute: isObjectAttribute,
    format: format,
    setCookie:setCookie,
    getCookie:getCookie,
    removeCookie:removeCookie,
    getDateInterval:getDateInterval,
    GUID:GUID,
    toPercent:toPercent,
    swap:swap
}

//export default _.defaultsDeep({
//    isObjectAttribute:isObjectAttribute,
//    format:format
//},qipan)


// WEBPACK FOOTER //
// ./src/core/utils.js